package com.example.kt_wear_app.presentation.utils

import okhttp3.*
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody.Companion.asRequestBody
import okhttp3.RequestBody.Companion.toRequestBody
import java.io.File
import java.io.IOException
import java.net.URLEncoder
import okhttp3.Interceptor
import okhttp3.Response

object HttpRequestUtils {
    private const val BASE_URL = "https://sf.giftwl.com/api"  // 修复引号问题，添加常量修饰符

    // 修改client初始化方式，添加拦截器
    private val client = OkHttpClient.Builder()
        .addInterceptor(AuthInterceptor())
        .build()

    // 新增拦截器类
    private class AuthInterceptor : Interceptor {
        override fun intercept(chain: Interceptor.Chain): Response {
            val originalRequest = chain.request()
            
            // 从本地获取token（需要实现getAuthToken方法）
            getAuthToken()?.let { token ->
                // 添加带token的新请求
                val newRequest = originalRequest.newBuilder()
                    .header("token", token)
                    .build()
                return chain.proceed(newRequest)
            }
            
            // 无token继续原始请求
            return chain.proceed(originalRequest)
        }
    }

    // 新增token获取方法（需要用户实现具体存储逻辑）
    private fun getAuthToken(): String? {
        // 这里实现从SharedPreferences或其他存储获取token的逻辑
        val token = SharedPreferencesUtils.getString("token");
        println("token-----------$token")
        return token
    }

    /*------------------ 公共方法 ------------------*/
    /**
     * 发起 GET 请求
     * @param path 请求路径（自动拼接基础URL）
     * @param params 请求参数（可选）
     * @param callback 请求结果回调
     */
    fun get(path: String, params: Map<String, Any>? = null, callback: Callback) {
        val fullUrl = "$BASE_URL/$path"
        val request = Request.Builder()
            .url(buildUrlWithParams(fullUrl, params ?: emptyMap()))
            .build()
        enqueueRequest(request, callback)
    }

    /**
     * 发起 POST 请求
     * @param path 请求路径（自动拼接基础URL）
     * @param params 表单参数（可选）
     * @param callback 请求结果回调
     */
    fun post(path: String, params: Map<String, Any>? = null, callback: Callback) {
        val fullUrl = "$BASE_URL/$path"
        val formBody = buildFormBody(params ?: emptyMap())
        val request = Request.Builder()
            .url(fullUrl)
            .post(formBody)
            .build()
        enqueueRequest(request, callback)
    }

    /*------------------ 文件操作 ------------------*/
    /**
     * 上传文件
     * @param path 上传路径（自动拼接基础URL）
     * @param file 要上传的文件
     * @param fileParamName 文件表单字段名
     * @param callback 请求结果回调
     */
    fun uploadFile(path: String, file: File, fileParamName: String, callback: Callback) {
        val fullUrl = "$BASE_URL/$path"
        val requestBody = MultipartBody.Builder()
            .setType(MultipartBody.FORM)
            .addFormDataPart(fileParamName, file.name, file.asRequestBody())
            .build()
        
        val request = Request.Builder()
            .url(fullUrl)
            .post(requestBody)
            .build()
        enqueueRequest(request,callback)
    }

    /*------------------ 私有工具方法 ------------------*/
    private fun enqueueRequest(request: Request, callback: Callback) {
        client.newCall(request).enqueue(object : Callback {
            override fun onFailure(call: Call, e: IOException) {
                // 统一错误处理
            }

            override fun onResponse(call: Call, response: Response) {
                // 统一响应处理
                callback.onResponse(call, response)
            }
        })
    }

    private fun buildFormBody(params: Map<String, Any>): FormBody {
        return FormBody.Builder().apply {
            params.forEach { (key, value) ->
                addEncoded(key, value.toString().encodeParam())
            }
        }.build()
    }

    private fun buildUrlWithParams(baseUrl: String, params: Map<String, Any>): String {
        if (params.isEmpty()) {
            return baseUrl
        }
        val paramString = params.entries.joinToString("&") { (key, value) ->
            "${key.encodeParam()}=${value.toString().encodeParam()}"
        }
        return if (baseUrl.contains("?")) {
            "$baseUrl&$paramString"
        } else {
            "$baseUrl?$paramString"
        }
    }

    private fun String.encodeParam(): String {
        return URLEncoder.encode(this, "UTF-8")
    }
}
